import java.util.Scanner;
import java.util.LinkedList;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Arrays;
import java.util.Queue;
import java.util.List;
import java.util.ArrayList;
import java.util.Stack;

// import java.util.Vector;
// import java.util.Collections;
// import java.util.Comparator;
// import java.util.Iterator;
// import java.util.Enumeration;

public class Calc 
{
	
	// 数值类型数据类型
	// int age = 25;
	// byte smallNumber = 100;
	// short mediumNumber = 1000;
	// long bigNumber = 1000000000L;
	// float smallDecimal = 23.4f;
	// double bigDecimal = 123.456;
	// char letter = 'A';
	// boolean isStudent = true;
	
	// 引用类型数据类型
	// String name = "Alice";
	// int[] numbers = {1, 2, 3, 4, 5};
	// MyClass myObject = new MyClass();
	
	
	// 集合框架类型
	// Deque：双端队列，允许在两端进行插入和删除操作。
	// Queue：单端队列，只允许在队列尾部插入元素，在头部删除元素。
	// List：有序集合，允许在任意位置插入和删除元素。
	// Stack：后进先出的集合类，继承自 Vector。

	// --Queue接口类
	// import java.util.Queue;
	// import java.util.LinkedList;

	// public class Main {
		
		// public static void main(String[] args) {
			
			// Queue<Double> queue = new LinkedList<>();
			// queue.add(15.0);
			// queue.add(20.0);
			
			// System.out.println("队列头部元素: " + queue.peek());
			// System.out.println("移除头部元素: " + queue.remove());
			// System.out.println("队列剩余元素: " + queue);
		// }
	// }
	
	// --List接口类
	// import java.util.List;
	// import java.util.ArrayList;

	// public class Main {
		
		// public static void main(String[] args) {
			
			// List<Double> list = new ArrayList<>();
			// list.add(15.0);
			// list.add(20.0);
			
			// System.out.println("列表第一个元素: " + list.get(0));
			// System.out.println("移除第一个元素: " + list.remove(0));
			// System.out.println("列表剩余元素: " + list);
		// }
	// }
	
	// --Stack接口类
	// import java.util.Stack;

	// public class Main {
		// public static void main(String[] args) {
			
			// Stack<Double> stack = new Stack<>();
			// stack.push(15.0);
			// stack.push(20.0);
			
			// System.out.println("栈顶元素: " + stack.peek());
			// System.out.println("移除栈顶元素: " + stack.pop());
			// System.out.println("栈剩余元素: " + stack);
		// }
	// }
	
	public static void main(String[] args)
	{
		Scanner scanner = new Scanner(System.in);
		System.out.println("Java 控制台计算器");
		
		String input = scanner.nextLine().trim();
		
		if (input.isEmpty()) {
			System.out.println("错误：输入不能为空~");
		}
		
		if (input.equalsIgnoreCase("exit")) {
			System.out.println("程序已退出~");
		}
		
		// 包含预设值列表
		// Deque<Double> numbers = new ArrayDeque<>(Arrays.asList(15.0, 20.0));
		// Deque<String> numbers = new ArrayDeque<>(Arrays.asList("hello", "world"));
		Deque<Float> numbers = new ArrayDeque<>(Arrays.asList(1.0f, 2.0f, 3.0f));
		System.out.println(numbers);
		// System.exit(0);

		System.out.println(testInt());
		
		// 集合框架 Queue
		// Queue<Double> queue = new LinkedList<>(Arrays.asList(17.0, 24.0));
		Queue<String> queues = new LinkedList<>(Arrays.asList("hello1", "world1"));
		System.out.println(queues);
		System.exit(0);
		
		// 集合框架 List
		List<Integer> lists = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
		System.out.println(lists);

		List<String> list2 = new ArrayList<>(Arrays.asList("hello", "world"));
		System.out.println(list2);
		System.exit(0);

		// 集合框架-栈 Stack
		// Stack<Integer> stack = new Stack<>();
		// // stack.addAll(Arrays.asList("hello", "world"));
		// stack.addAll(Arrays.asList(1, 2 , 3));
		// // Stack<Double> stack2 = new Stack<>(Arrays.asList(1.0,2.0,3.0));
		// // stack.push("hello");
		// // stack.push("world");
		
		// System.out.println(stack);
		
		
		// 断点操作
		// System.exit(0);
		// System.out.println("Hello World ~");
		
		// System.out.println(title);
		
		// System.out.println("hello world~");
		
		// evaluateExpression(input);
	}
	
	public static int testInt()
	{
		return 2025;
	}
	
	public static Number test()
	{
		String title = "hello world";
		
		Number num = 4;
		
		return num;
		
		// System.out.println(title);
	}
	
	// 计算方式
	// public static void evaluateExpression(String expression)
	// {
		// String expr = expression.replaceAll("\\s+",  "");
		
		// // 必须是数字
		// if (!expr.matches("[\\d.+\\-*/]+"))
		// {
			// throw new IllegalArgumentException("包含非法字符");
		// }
		
		// Deque<Double> numbers = new ArrayDeque<>();
        // Deque<Character> operators = new ArrayDeque<>();
				
		// // System.out.println(expr);
		
		// for (int i = 0; i < expr.length(); i++) {
			
			// char c = expr.charAt(i); 
			// // System.out.println(Character.isDigit(c));
			
			// if (Character.isDigit(c)  || c == '.') {
				// StringBuilder numBuilder = new StringBuilder();
				
				// // 将单个字符组合
				// while (i < expr.length()  && 
                      // (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
						  
                    // numBuilder.append(expr.charAt(i++));
                // }
                // i--;
				
				// // 单字符追加到数组
				// try {
                    // double number = Double.parseDouble(numBuilder.toString()); 
                    // numbers.push(number); 
                // } catch (NumberFormatException e) {
                    // throw new IllegalArgumentException("无效数字格式: " + numBuilder);
                // }
			// }
			
			// // 处理运算符 
            // else if (isOperator(c)) {
                // while (!operators.isEmpty() && 
                      // hasPrecedence(c, operators.peek())) {
                    // calculateTop(numbers, operators);
                // }
                // operators.push(c); 
            // } else {
                // throw new IllegalArgumentException("无效字符: " + c);
            // }
			
			// // 计算剩余操作
			// while (!operators.isEmpty()) {
				// calculateTop(numbers, operators);
			// }
			
			// if (numbers.size()  != 1 || !operators.isEmpty())  {
				// throw new IllegalArgumentException("无效表达式格式");
			// }
			
			// return numbers.pop(); 
		// }
	// }
	
	
	/**
     * 执行栈顶运算 
     */
    private static void calculateTop(Deque<Double> numbers, Deque<Character> operators) 
	{
		
        if (numbers.size()  < 2 || operators.isEmpty()) {
            throw new IllegalArgumentException("运算符缺失");
        }
        
        double b = numbers.pop(); 
        double a = numbers.pop(); 
        char op = operators.pop(); 
        
        switch (op) {
            case '+': numbers.push(a  + b); break;
            case '-': numbers.push(a  - b); break;
            case '*': numbers.push(a  * b); break;
            case '/': 
                if (b == 0) throw new ArithmeticException("除零错误");
                numbers.push(a  / b); 
                break;
            default: throw new IllegalArgumentException("不支持的操作符: " + op);
        }
    }
	
	/**
     * 检查运算符优先级 
     * @param current 当前运算符 
     * @param previous 栈顶运算符 
     * @return 当前运算符是否优先级较低或相等
     */
    private static boolean hasPrecedence(char current, char previous) {
        if (previous == '(' || previous == ')') return false;
        return (current != '*' && current != '/') || 
               (previous != '+' && previous != '-');
    }
 
    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }
	
	
}

